#ifndef GLOBAL_H
#define GLOBAL_H

#include <vector>
#include <iostream>
#include <limits>
#include "Singleton.h"


//#define GPU_INCLUDED


//     parametry programu cool - umieszczono tu glowne zmienne
//     programu, ktore musza byc zalozone tzn. nie moga byc
//     wyliczone
//

//#define	MW_MAX	        20    // maksymalna ilosc kolumn wezlow
//#define	NW_MAX       	20    // maksymalna ilosc wezlow w kolumnie
#define	NSTP_MAX	30    // maksymalny rozmiar tablicy pamietajacej temper.
#define	ILDTMAX         10
#define	IZARMAX         100
#define	MWMAX           440    // max. ilosc pionowych linii podzialow
#define	NWMAX           440    // max. ilosc poziomych linii podzialow
#define	NKSZTMAX	2     // max. ilosc opisanych ksztaltow
#define	NRPKTMAX	17    // max. ilosc punktow opisujacych ksztalt w maczar [0,1,2,3]
#define	NSTPMAX         100


class Global : public Singleton<Global> {
public:

    Global() :
    tpc(NSTPMAX + 2, std::vector<double>(MWMAX + 1)),
    tp(MWMAX * NWMAX),    
    maczar(maczarData),
    PROJECT_DIR(""),
    tempgrd(0.0),
    LICZ(0)
    {

    }
    
    
    int getalf(double xp, double yp, double xk,
            double yk, double r, double xr, double yr,
            double *alp, double *alk, double *tpk);

    int getfi(double x, double y, double xr, double yr, double *fi);

    bool mPodzDefault;   // dodane
    bool nPodzDefault;   // dodane
    int kod[(MWMAX - 1)*(NWMAX - 1)];
    int ib[MWMAX * NWMAX];
    double q[MWMAX * NWMAX];
    double xvv[MWMAX * NWMAX];
    double dteps[MWMAX * NWMAX];
    double tweps[MWMAX * NWMAX];
    
    std::string PROJECT_DIR;
    int LICZ;

    
    int nstem[MWMAX * NWMAX];
    double tprzem[MWMAX * NWMAX];
    
    std::vector<std::vector<double> > tpc;
    int iy[(MWMAX - 1)*(NWMAX - 1)][4];
    //   double wspolczAw[4];
    //   double wspoldAo[4];
    //   double wspmi2A2[4];
    double x[MWMAX*NWMAX];
    double y[MWMAX*NWMAX];
    double xn[MWMAX*NWMAX];
    double yn[MWMAX*NWMAX];
    double valx[MWMAX*NWMAX];
    double valy[MWMAX*NWMAX];
    double valxn[MWMAX*NWMAX];
    double valyn[MWMAX*NWMAX];
    std::vector<double> tp;
    double rnorm;
    double przemxv;
    std::vector<int> v_ndt;
    std::vector<double> v_dt;


    int rot(double *x, double *y, double sinfi, double cosfi);

    int istem;
    int kkod1, kkod2, kkod3, kkod4;
    double temgrd;
    int iwkod;

    double tpas0;
    int iprint;
    double tempgrd;
    int iwn;
    int iw;
    int ie;
    int ichl;

    struct t_ral {
        std::vector<double> ralfa, ralfpo, ralfpn;
        double ralfae, tpocz, tpow, tchcal;
        bool ispray;
    } ral;

    struct t_nkp {
        double xchard, ychard, xcharld, ycharld, xchar, ychar, xcharl, ycharl;
        int ichar, ichard, icharl, icharld, nkszt, mw_max, nw_max, me, ne,
                mw, nw, nstd, nx1, nx2, nx, ny1, ny2, ny, nxd1, nxd2, nxd, nyd1, nyd2, nyd;
    } nkp;

    struct t_zargd {
        double xp[2 * IZARMAX], yp[2 * IZARMAX], rp[2 * IZARMAX], xrp[2 * IZARMAX],
                yrp[2 * IZARMAX], alpp[2 * IZARMAX], alkp[2 * IZARMAX], ttp[2 * IZARMAX],
                xw[2 * MWMAX * NWMAX], xpodz[MWMAX], ypodz[NWMAX];
    } zargd;

    struct t_mnmx {
        double xmin, ymin, sc;
    } mnmx;



    struct t_maczar {
        double xyrpgall[NKSZTMAX][NRPKTMAX][3], xyrpdall[NKSZTMAX][NRPKTMAX][3],
                xprep[NKSZTMAX][MWMAX], yprep[NKSZTMAX][NWMAX],
                xchrl[NKSZTMAX], ychrl[NKSZTMAX],
                xchrld[NKSZTMAX], ychrld[NKSZTMAX],
                xchr[NKSZTMAX], ychr[NKSZTMAX],
                xchrd[NKSZTMAX], ychrd[NKSZTMAX];
        int npgall[NKSZTMAX], npdall[NKSZTMAX], mwprep[NKSZTMAX], nwprep[NKSZTMAX];
    } ;//
    t_maczar maczar;
    
    static t_maczar const maczarData;

};



#define GLOB Global::GetSingleton()



#endif	

